﻿// Decompiled with JetBrains decompiler
// Type: DnProcessSimulateCommands.ApplyPathTemplateAction.CUIApplyPathTemplateActionDlg
// Assembly: DnProcessSimulateCommands, Version=2402.0.0.890, Culture=neutral, PublicKeyToken=null
// MVID: A885D881-AEDF-447E-852A-6F13102E089C
// Assembly location: C:\Program Files\Tecnomatix_2402\eMPower\DotNetCommands\DnProcessSimulateCommands.dll

using EngineeringInternalExtension;
using System;
using System.Collections;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Drawing;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Windows.Forms.Layout;
using Tecnomatix.Engineering;
using Tecnomatix.Engineering.Olp;
using Tecnomatix.Engineering.Olp.RoboticPathTemplate;
using Tecnomatix.Engineering.PrivateImplementationDetails;
using Tecnomatix.Engineering.Ui;


namespace DnProcessSimulateCommands.ApplyPathTemplateAction;

internal class CUIApplyPathTemplateActionDlg : TxForm, IPathTemplateData
{
  private CApApplyPathTemplateUtil m_util = new CApApplyPathTemplateUtil();
  private TxCompositeValidator m_validator;
  private TxOlpPathTemplateServices m_service;
  private bool m_shouldSetActionList = true;
  private TxForm m_generatedDialog;
  private bool m_errorFound;
  private TxRobot m_previousRobot;
  private TxContextMenuStrip m_cmnCommands = new TxContextMenuStrip();
  private string fullActionName = "";
  private const string C_STR_MENU_ITEM_HORIZONTAL_SEPARATOR = "-";
  private static readonly Regex C_REGEX_MENU_ITEM_HORIZONTAL_SEPARATOR = new Regex("^\\-+$");
  private bool m_allowComponenets;
  private TxRobot m_robot;
  internal TxColor m_selectionColor = new TxColor((byte) 64 /*0x40*/, (byte) 224 /*0xE0*/, (byte) 208 /*0xD0*/);
  private IContainer components;
  private Button OKButton;
  private Button cancelButton;
  private Label label1;
  private Button ApplayButton;
  private RichTextBox Description;
  private Label label2;
  private TxObjGridCtrl OperationGrid;
  private Label label3;
  private Button SetButton;
  private PictureBox SettingIcon;
  private ToolTip ttSetIcons;
  private Button RefreshButton;
  private Button SelectActionBt;
  private TextBox actionNameBx;
  private Button ClearBn;

  internal CUIApplyPathTemplateActionDlg() => this.InitializeComponent();

  private void CUIApplyPathTemplateActionDlg_Load(object sender, EventArgs e)
  {
    // ISSUE: unable to decompile the method.
  }

  private void DialogClosed(object sender, FormClosedEventArgs e)
  {
    if (this.m_generatedDialog == null)
      return;
    ((Form) this.m_generatedDialog).Close();
  }

  private void InitPathTemplateServices()
  {
    if (((Collection<ITxObject>) this.OperationGrid.Objects).Count <= 0)
      return;
    Cursor current = Cursor.Current;
    Cursor.Current = Cursors.WaitCursor;
    try
    {
      this.PathTemplateServices.LoadControllerXMLInfo((ITxRobotController) this.Robot.Controller);
    }
    catch (Exception ex)
    {
      this.PathTemplateServices = (TxOlpPathTemplateServices) null;
      if (!this.m_errorFound)
      {
        if (TxMessageBox.Show(PathTemplateActionStringTable.XML_ERROR, PathTemplateActionStringTable.CMD_NAME, MessageBoxButtons.YesNo, MessageBoxIcon.Hand) == DialogResult.Yes)
        {
          if (TxCommandLicenser.CustomizedUILicense)
          {
            new TxCommandManager().ExecuteCommandByCommandProgId("CUICustomizedCommandXMLCheckerCmd", (object) this.Robot, false);
          }
          else
          {
            int num = (int) TxMessageBox.Show(PathTemplateActionStringTable.NoLicenseForChecker, PathTemplateActionStringTable.CMD_NAME, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
          }
        }
        this.m_errorFound = true;
        ((Form) this).Close();
      }
    }
    ((ToolStrip) this.m_cmnCommands).Items.Clear();
    this.actionNameBx.Text = string.Empty;
    this.fullActionName = string.Empty;
    Cursor.Current = current;
  }

  private void OnSelectedAction(object sender, EventArgs e)
  {
    if (!(sender.GetType() == typeof (ToolStripMenuItem)))
      return;
    ToolStripMenuItem toolStripMenuItem = sender as ToolStripMenuItem;
    this.actionNameBx.Text = toolStripMenuItem.Text;
    this.fullActionName = toolStripMenuItem.Tag.ToString();
    this.Description.Text = this.PathTemplateServices.GetActionDescription(this.fullActionName);
    this.SetButtonsStatus();
  }

  private void SetActionList()
  {
    string str1 = this.fullActionName;
    ((ToolStrip) this.m_cmnCommands).Items.Clear();
    this.fullActionName = string.Empty;
    this.Description.Text = string.Empty;
    if (((Collection<ITxObject>) this.OperationGrid.Objects).Count == 0)
    {
      this.actionNameBx.Text = string.Empty;
      str1 = string.Empty;
    }
    else
    {
      if (((Collection<ITxObject>) this.OperationGrid.Objects).Count <= 0 || this.PathTemplateServices == null)
        return;
      ArrayList arrayList1 = new ArrayList();
      if (!this.m_allowComponenets)
      {
        foreach (object roboticOperation in (Collection<ITxObject>) this.m_util.GetAllSubRoboticOperations(this.OperationGrid.Objects))
        {
          TxOlpPathTemplateOperationFilter templateOperationFilter = (TxOlpPathTemplateOperationFilter) 5;
          switch (roboticOperation)
          {
            case ITxWeldOperation _:
              templateOperationFilter = (TxOlpPathTemplateOperationFilter) 1;
              break;
            case TxGenericRoboticOperation _:
              templateOperationFilter = (TxOlpPathTemplateOperationFilter) 2;
              break;
            case ITxContinuousOperation _:
              templateOperationFilter = (TxOlpPathTemplateOperationFilter) 3;
              break;
            case TxRoboticSeamOperation _:
              templateOperationFilter = (TxOlpPathTemplateOperationFilter) 4;
              break;
          }
          if (templateOperationFilter != 5 && !arrayList1.Contains((object) templateOperationFilter))
            arrayList1.Add((object) templateOperationFilter);
        }
        ArrayList intersectionActions = new ArrayList((ICollection) (this.PathTemplateServices.FilterActionMap[arrayList1[0]] as ArrayList));
        for (int index = 1; index < arrayList1.Count; ++index)
        {
          ArrayList arrayList2 = new ArrayList();
          ArrayList filterAction = this.PathTemplateServices.FilterActionMap[arrayList1[index]] as ArrayList;
          foreach (string str2 in intersectionActions)
          {
            if (!filterAction.Contains((object) str2))
              arrayList2.Add((object) str2);
          }
          foreach (string str3 in arrayList2)
            intersectionActions.Remove((object) str3);
        }
        foreach (string str4 in this.PathTemplateServices.FilterActionMap[(object) (TxOlpPathTemplateOperationFilter) 0] as ArrayList)
        {
          if (!intersectionActions.Contains((object) str4))
            intersectionActions.Add((object) str4);
        }
        this.AddActionsToContextMenue(intersectionActions);
      }
      else
        this.AddActionsToContextMenue(new ArrayList((ICollection) (this.PathTemplateServices.FilterActionMap[(object) (TxOlpPathTemplateOperationFilter) 6] as ArrayList)));
    }
  }

  private void AddActionsToContextMenue(ArrayList intersectionActions)
  {
    if (intersectionActions.Count <= 0)
      return;
    foreach (object intersectionAction in intersectionActions)
    {
      string str1 = intersectionAction.ToString();
      if (str1 != "")
      {
        string[] strArray = str1.Split('|');
        int length = strArray.GetLength(0);
        ToolStripMenuItem toolStripMenuItem1 = (ToolStripMenuItem) null;
        foreach (ToolStripMenuItem toolStripMenuItem2 in (ArrangedElementCollection) ((ToolStrip) this.m_cmnCommands).Items)
        {
          if (toolStripMenuItem2.Text == strArray[0])
          {
            toolStripMenuItem1 = toolStripMenuItem2;
            break;
          }
        }
        if (toolStripMenuItem1 == null)
        {
          toolStripMenuItem1 = new ToolStripMenuItem();
          toolStripMenuItem1.Text = strArray[0];
          if (length > 1)
          {
            toolStripMenuItem1.Tag = (object) str1;
            ((ToolStrip) this.m_cmnCommands).Items.Add((ToolStripItem) toolStripMenuItem1);
          }
          else
          {
            ToolStripMenuItem toolStripMenuItem3 = new ToolStripMenuItem(strArray[0], (Image) null, new EventHandler(this.OnSelectedAction));
            toolStripMenuItem3.Tag = (object) str1;
            ((ToolStrip) this.m_cmnCommands).Items.Add((ToolStripItem) toolStripMenuItem3);
          }
        }
        for (int index = 1; index < length - 1; ++index)
        {
          bool flag = false;
          foreach (ToolStripMenuItem dropDownItem in (ArrangedElementCollection) toolStripMenuItem1.DropDownItems)
          {
            if (dropDownItem.Text == strArray[index])
            {
              toolStripMenuItem1 = dropDownItem;
              flag = true;
              break;
            }
          }
          if (!flag)
          {
            ToolStripMenuItem toolStripMenuItem4 = new ToolStripMenuItem();
            toolStripMenuItem4.Tag = (object) str1;
            toolStripMenuItem4.Text = strArray[index];
            toolStripMenuItem1.DropDownItems.Add((ToolStripItem) toolStripMenuItem4);
            toolStripMenuItem1 = toolStripMenuItem4;
          }
        }
        string str2 = strArray[length - 1];
        if (CUIApplyPathTemplateActionDlg.C_REGEX_MENU_ITEM_HORIZONTAL_SEPARATOR.IsMatch(str2))
          str2 = "-";
        ToolStripMenuItem toolStripMenuItem5 = new ToolStripMenuItem(str2, (Image) null, new EventHandler(this.OnSelectedAction));
        toolStripMenuItem5.Tag = (object) str1;
        toolStripMenuItem1.DropDownItems.Add((ToolStripItem) toolStripMenuItem5);
      }
    }
  }

  private void RefreshAll()
  {
    if (!this.m_errorFound)
    {
      if (!this.m_allowComponenets)
        this.SetRobot();
      if (this.m_shouldSetActionList)
        this.SetActionList();
      this.SetActionListStatus();
      this.SetButtonsStatus();
    }
    TxApplication.RefreshDisplay();
  }

  private void SetRobot()
  {
    if (((Collection<ITxObject>) this.OperationGrid.Objects).Count > 0)
    {
      TxRobot robot = this.m_util.GetRobot(((Collection<ITxObject>) this.OperationGrid.Objects)[0] as ITxOperation);
      if (TxRobot.op_Inequality(robot, (ITxObject) this.Robot))
      {
        this.Robot = robot;
        if (TxRobot.op_Inequality(this.m_previousRobot, (ITxObject) this.Robot))
          this.InitPathTemplateServices();
      }
      ((Control) this).Text = $"{PathTemplateActionStringTable.DLG_NAME} [{((TxBaseGeometryCreationObject) this.Robot).Name}]";
    }
    else
    {
      this.Robot = (TxRobot) null;
      ((Control) this).Text = PathTemplateActionStringTable.DLG_NAME;
      ((ToolStrip) this.m_cmnCommands).Items.Clear();
      this.fullActionName = string.Empty;
      this.actionNameBx.Text = string.Empty;
      this.Description.Text = string.Empty;
    }
  }

  private void SetActionListStatus()
  {
    if (((Collection<ITxObject>) this.OperationGrid.Objects).Count == 0)
    {
      ((ToolStrip) this.m_cmnCommands).Items.Clear();
      this.fullActionName = string.Empty;
      this.actionNameBx.Text = string.Empty;
      this.SelectActionBt.Enabled = false;
    }
    else
      this.SelectActionBt.Enabled = true;
  }

  private void SetButtonsStatus()
  {
    if (((Collection<ITxObject>) this.OperationGrid.Objects).Count == 0)
    {
      this.RefreshButton.Enabled = false;
      this.ClearBn.Enabled = false;
    }
    else
    {
      this.RefreshButton.Enabled = true;
      this.ClearBn.Enabled = true;
    }
    if (((Collection<ITxObject>) this.OperationGrid.Objects).Count == 0 || this.fullActionName == "")
    {
      this.OKButton.Enabled = false;
      this.ApplayButton.Enabled = false;
      this.SetButton.Enabled = false;
      this.SettingIcon.Hide();
    }
    else
    {
      this.OKButton.Enabled = true;
      this.ApplayButton.Enabled = true;
      this.SetButton.Enabled = this.PathTemplateServices.IsGenerateDialogNeeded(this.fullActionName);
      if (this.SetButton.Enabled)
        this.SettingIcon.Show();
      else
        this.SettingIcon.Hide();
      if (this.SetButton.Enabled && !this.PathTemplateServices.HaveRealSetting.Contains(this.fullActionName))
      {
        this.OKButton.Enabled = false;
        this.ApplayButton.Enabled = false;
        this.SettingIcon.Image = (Image) PathTemplateActionStringTable.warningsmall;
        this.ttSetIcons.SetToolTip((Control) this.SettingIcon, PathTemplateActionStringTable.TTWarningsmall);
      }
      else
      {
        if (!this.PathTemplateServices.HaveRealSetting.Contains(this.fullActionName))
          return;
        this.SettingIcon.Image = (Image) PathTemplateActionStringTable.check;
        this.ttSetIcons.SetToolTip((Control) this.SettingIcon, PathTemplateActionStringTable.TTCheck);
      }
    }
  }

  private void txObjGridCtrl1_ObjectInserted(
    object sender,
    TxObjGridCtrl_ObjectInsertedEventArgs args)
  {
    if (args.Obj is ITxDisplayableObject)
      TxDisplayableObjectEx.EmphasizeObject(args.Obj as ITxDisplayableObject, this.m_selectionColor, (TxColorEmphasizePriority) 1);
    this.RefreshAll();
  }

  private void txObjGridCtrl1_Picked(object sender, TxObjGridCtrl_PickedEventArgs args)
  {
  }

  private void txObjGridCtrl1_InvalidObjectTyped(
    object sender,
    TxObjGridCtrl_InvalidObjectTypedEventArgs args)
  {
    this.OKButton.Enabled = false;
    this.ApplayButton.Enabled = false;
  }

  private void OperationGrid_ObjectDeleting(
    object sender,
    TxObjGridCtrl_ObjectDeletingEventArgs args)
  {
    if (args.Obj is ITxDisplayableObject)
      TxDisplayableObjectEx.StopEmphasizeObject(args.Obj as ITxDisplayableObject, this.m_selectionColor, (TxColorEmphasizePriority) 1);
    this.RefreshAll();
  }

  private void txObjGridCtrl1_ValidObjectTyped(
    object sender,
    TxObjGridCtrl_ValidObjectTypedEventArgs args)
  {
    this.RefreshAll();
  }

  private void txObjGridCtrl1_RowDeleted(object sender, TxObjGridCtrl_RowDeletedEventArgs args)
  {
    this.RefreshAll();
  }

  private void OKButton_Click(object sender, EventArgs e)
  {
    this.ExecuteAction();
    ((Form) this).Close();
  }

  private void GeneratedDialogClosed(object sender, FormClosedEventArgs e)
  {
    this.EnableAllAfterApplayingCommand();
    this.SetButtonsStatus();
    this.m_generatedDialog = (TxForm) null;
  }

  private void EnableAllAfterApplayingCommand()
  {
    this.SelectActionBt.Enabled = true;
    ((Control) this.OperationGrid).Enabled = true;
    this.SetButtonsStatus();
  }

  private void DisabledAllAfterApplayingCommand()
  {
    this.SelectActionBt.Enabled = false;
    ((Control) this.OperationGrid).Enabled = false;
    this.OKButton.Enabled = false;
    this.ApplayButton.Enabled = false;
    this.SetButton.Enabled = false;
    this.RefreshButton.Enabled = false;
  }

  private void ExecuteAction()
  {
    Cursor current = Cursor.Current;
    Cursor.Current = Cursors.WaitCursor;
    try
    {
      this.PathTemplateServices.ApplyAction(this.m_util.GetAllSubRoboticOperations(this.OperationGrid.Objects), this.fullActionName, this.Robot);
    }
    catch (Exception ex)
    {
      int num = (int) TxMessageBox.Show(ex.Message, PathTemplateActionStringTable.CMD_NAME, MessageBoxButtons.OK, MessageBoxIcon.Hand);
    }
    finally
    {
      this.EnableAllAfterApplayingCommand();
      Cursor.Current = current;
    }
  }

  internal void ExecuteAction(TxObjectList Operations, string fullActionName)
  {
    Cursor current = Cursor.Current;
    Cursor.Current = Cursors.WaitCursor;
    try
    {
      if (Operations == null || ((Collection<ITxObject>) Operations).Count <= 0 || !(((Collection<ITxObject>) Operations)[0] is ITxOperation))
        return;
      TxRobot robot = new TxOlpControllerUtilities().GetRobot(((Collection<ITxObject>) Operations)[0] as ITxOperation);
      if (!TxRobot.op_Inequality(robot, (ITxObject) null))
        return;
      this.PathTemplateServices.LoadControllerXMLInfo((ITxRobotController) robot.Controller);
      this.PathTemplateServices.ApplyAction(Operations, fullActionName, this.Robot);
    }
    catch
    {
    }
    finally
    {
      Cursor.Current = current;
    }
  }

  private void SelectActionBt_Click(object sender, EventArgs e)
  {
    ((ToolStripDropDown) this.m_cmnCommands).Show((Control) this.SelectActionBt, new Point(0, this.SelectActionBt.Size.Height));
  }

  private void cancelButton_Click(object sender, EventArgs e)
  {
    foreach (ITxObject itxObject in (Collection<ITxObject>) this.OperationGrid.Objects)
    {
      if (itxObject is ITxDisplayableObject)
        TxDisplayableObjectEx.StopEmphasizeObject(itxObject as ITxDisplayableObject, this.m_selectionColor, (TxColorEmphasizePriority) 1);
    }
    ((Form) this).Close();
  }

  private void ApplayButton_Click(object sender, EventArgs e)
  {
    this.ExecuteAction();
    this.OKButton.Enabled = false;
  }

  private void SetButton_Click(object sender, EventArgs e)
  {
    this.DisabledAllAfterApplayingCommand();
    this.PathTemplateServices.Robot = this.Robot;
    this.m_generatedDialog = this.PathTemplateServices.ShowDialog(this.fullActionName, this.m_util.GetAllSubRoboticOperations(this.OperationGrid.Objects));
    ((Form) this.m_generatedDialog).FormClosed += new FormClosedEventHandler(this.GeneratedDialogClosed);
  }

  private void RefreshButton_Click(object sender, EventArgs e)
  {
    Cursor current = Cursor.Current;
    Cursor.Current = Cursors.WaitCursor;
    try
    {
      try
      {
        new TxOlpDataServices(this.Robot).Refresh();
      }
      catch (TxOlpXMLMissingOlpConfigurationFileException ex)
      {
      }
      try
      {
        new TxOlpCommandServices(this.Robot).Refresh();
      }
      catch (TxOlpXMLMissingOlpConfigurationFileException ex)
      {
      }
      try
      {
        new TxOlpMotionCommandServices(this.Robot).Refresh();
      }
      catch (TxOlpXMLMissingOlpConfigurationFileException ex)
      {
      }
    }
    catch
    {
    }
    finally
    {
      if (this.m_service != null)
        this.m_service.CloseResultDialog();
      this.m_service = (TxOlpPathTemplateServices) null;
      this.RefreshAll();
      Cursor.Current = current;
    }
  }

  private void ClearBn_Click(object sender, EventArgs e)
  {
    this.StopAllEmphasize();
    this.OperationGrid.Objects = new TxObjectList();
    this.RefreshAll();
  }

  private void StopAllEmphasize()
  {
    if (this.OperationGrid.Objects == null || ((Collection<ITxObject>) this.OperationGrid.Objects).Count <= 0)
      return;
    foreach (ITxObject itxObject in (Collection<ITxObject>) this.OperationGrid.Objects)
    {
      if (itxObject is ITxDisplayableObject)
        TxDisplayableObjectEx.StopEmphasizeObject(itxObject as ITxDisplayableObject, this.m_selectionColor, (TxColorEmphasizePriority) 1);
    }
    TxApplication.RefreshDisplay();
  }

  private void CUIApplyPathTemplateActionDlg_FormClosing(object sender, FormClosingEventArgs e)
  {
    this.StopAllEmphasize();
  }

  public TxRobot Robot
  {
    get => this.m_robot;
    set
    {
      if (TxRobot.op_Equality(value, (ITxObject) null))
        this.m_previousRobot = this.m_robot;
      this.m_robot = value;
    }
  }

  private TxOlpPathTemplateServices PathTemplateServices
  {
    get
    {
      if (this.m_service == null)
      {
        this.m_service = new TxOlpPathTemplateServices();
        this.InitPathTemplateServices();
      }
      return this.m_service;
    }
    set => this.m_service = value;
  }

  protected virtual void Dispose(bool disposing)
  {
    if (disposing && this.components != null)
      this.components.Dispose();
    base.Dispose(disposing);
  }

  private void InitializeComponent()
  {
    this.components = (IContainer) new Container();
    ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (CUIApplyPathTemplateActionDlg));
    this.OKButton = new Button();
    this.cancelButton = new Button();
    this.label1 = new Label();
    this.ApplayButton = new Button();
    this.Description = (RichTextBox) new TxRichTextBox();
    this.label2 = new Label();
    this.OperationGrid = new TxObjGridCtrl();
    this.label3 = new Label();
    this.SetButton = new Button();
    this.SettingIcon = new PictureBox();
    this.ttSetIcons = new ToolTip(this.components);
    this.RefreshButton = new Button();
    this.SelectActionBt = new Button();
    this.actionNameBx = new TextBox();
    this.ClearBn = new Button();
    ((ISupportInitialize) this.SettingIcon).BeginInit();
    ((Control) this).SuspendLayout();
    componentResourceManager.ApplyResources((object) this.OKButton, "OKButton");
    this.OKButton.Name = "OKButton";
    this.OKButton.UseVisualStyleBackColor = true;
    this.OKButton.Click += new EventHandler(this.OKButton_Click);
    componentResourceManager.ApplyResources((object) this.cancelButton, "cancelButton");
    this.cancelButton.Name = "cancelButton";
    this.cancelButton.UseVisualStyleBackColor = true;
    this.cancelButton.Click += new EventHandler(this.cancelButton_Click);
    componentResourceManager.ApplyResources((object) this.label1, "label1");
    this.label1.Name = "label1";
    componentResourceManager.ApplyResources((object) this.ApplayButton, "ApplayButton");
    this.ApplayButton.Name = "ApplayButton";
    this.ApplayButton.UseVisualStyleBackColor = true;
    this.ApplayButton.Click += new EventHandler(this.ApplayButton_Click);
    componentResourceManager.ApplyResources((object) this.Description, "Description");
    this.Description.Name = "Description";
    this.Description.ReadOnly = true;
    componentResourceManager.ApplyResources((object) this.label2, "label2");
    this.label2.Name = "label2";
    componentResourceManager.ApplyResources((object) this.OperationGrid, "OperationGrid");
    ((UserControl) this.OperationGrid).BorderStyle = BorderStyle.FixedSingle;
    this.OperationGrid.ChangeGeneralSelection = false;
    this.OperationGrid.CurrentRow = -1;
    this.OperationGrid.EnableMultipleSelection = true;
    this.OperationGrid.EnableRecurringObjects = false;
    this.OperationGrid.ListenToPick = false;
    ((Control) this.OperationGrid).Name = "OperationGrid";
    this.OperationGrid.PickLevel = (TxPickLevel) 6;
    this.OperationGrid.ReadOnly = false;
    this.OperationGrid.ValidatorType = (TxValidatorType) 10;
    this.OperationGrid.ObjectDeleting += new TxObjGridCtrl_ObjectDeletingEventHandler(this.OperationGrid_ObjectDeleting);
    this.OperationGrid.ObjectInserted += new TxObjGridCtrl_ObjectInsertedEventHandler(this.txObjGridCtrl1_ObjectInserted);
    this.OperationGrid.Picked += new TxObjGridCtrl_PickedEventHandler(this.txObjGridCtrl1_Picked);
    this.OperationGrid.RowDeleted += new TxObjGridCtrl_RowDeletedEventHandler(this.txObjGridCtrl1_RowDeleted);
    this.OperationGrid.InvalidObjectTyped += new TxObjGridCtrl_InvalidObjectTypedEventHandler(this.txObjGridCtrl1_InvalidObjectTyped);
    this.OperationGrid.ValidObjectTyped += new TxObjGridCtrl_ValidObjectTypedEventHandler(this.txObjGridCtrl1_ValidObjectTyped);
    componentResourceManager.ApplyResources((object) this.label3, "label3");
    this.label3.Name = "label3";
    componentResourceManager.ApplyResources((object) this.SetButton, "SetButton");
    this.SetButton.Name = "SetButton";
    this.SetButton.UseVisualStyleBackColor = true;
    this.SetButton.Click += new EventHandler(this.SetButton_Click);
    componentResourceManager.ApplyResources((object) this.SettingIcon, "SettingIcon");
    this.SettingIcon.Name = "SettingIcon";
    this.SettingIcon.TabStop = false;
    componentResourceManager.ApplyResources((object) this.RefreshButton, "RefreshButton");
    this.RefreshButton.Name = "RefreshButton";
    this.RefreshButton.UseVisualStyleBackColor = true;
    this.RefreshButton.Click += new EventHandler(this.RefreshButton_Click);
    componentResourceManager.ApplyResources((object) this.SelectActionBt, "SelectActionBt");
    this.SelectActionBt.Name = "SelectActionBt";
    this.SelectActionBt.UseVisualStyleBackColor = true;
    this.SelectActionBt.Click += new EventHandler(this.SelectActionBt_Click);
    componentResourceManager.ApplyResources((object) this.actionNameBx, "actionNameBx");
    this.actionNameBx.Name = "actionNameBx";
    this.actionNameBx.ReadOnly = true;
    componentResourceManager.ApplyResources((object) this.ClearBn, "ClearBn");
    this.ClearBn.Name = "ClearBn";
    this.ClearBn.UseVisualStyleBackColor = true;
    this.ClearBn.Click += new EventHandler(this.ClearBn_Click);
    ((ContainerControl) this).AutoScaleMode = AutoScaleMode.Font;
    componentResourceManager.ApplyResources((object) this, "$this");
    ((Control) this).Controls.Add((Control) this.ClearBn);
    ((Control) this).Controls.Add((Control) this.actionNameBx);
    ((Control) this).Controls.Add((Control) this.SelectActionBt);
    ((Control) this).Controls.Add((Control) this.RefreshButton);
    ((Control) this).Controls.Add((Control) this.SettingIcon);
    ((Control) this).Controls.Add((Control) this.SetButton);
    ((Control) this).Controls.Add((Control) this.OperationGrid);
    ((Control) this).Controls.Add((Control) this.label3);
    ((Control) this).Controls.Add((Control) this.Description);
    ((Control) this).Controls.Add((Control) this.label1);
    ((Control) this).Controls.Add((Control) this.cancelButton);
    ((Control) this).Controls.Add((Control) this.ApplayButton);
    ((Control) this).Controls.Add((Control) this.OKButton);
    ((Control) this).Controls.Add((Control) this.label2);
    ((Form) this).MaximizeBox = false;
    ((Form) this).MinimizeBox = false;
    ((Control) this).Name = nameof (CUIApplyPathTemplateActionDlg);
    this.ShouldCloseOnDocumentUnloading = true;
    ((Form) this).SizeGripStyle = SizeGripStyle.Hide;
    ((Form) this).FormClosing += new FormClosingEventHandler(this.CUIApplyPathTemplateActionDlg_FormClosing);
    ((Form) this).Load += new EventHandler(this.CUIApplyPathTemplateActionDlg_Load);
    ((ISupportInitialize) this.SettingIcon).EndInit();
    ((Control) this).ResumeLayout(false);
    ((Control) this).PerformLayout();
  }
}
